class backdrop
{
protected:
	IAnimatedMeshSceneNode      Nde;		//BackDrop Node
	stringw						Nam;		//Name of BackDrop
	float						Hzd;		//Damage Amount to User
	int							Clp;		//Object Clipping
	float						Swy;		//Bending Percentage
	float						Hth;		//Health Percentage of BackDrop
	stringw						Ste;		//State of BackDrop
	actor						Act;		//Actor
	int							Ani[][]	=	//Animation Table
	//	   Appr| Dsap| Actv| Stat| Coll|
		{{   -1,    3,    5,    7,    9},	//Beggining
		{     2,    4,    6,    8,   10},	//Ending
		{     0,    0,    0,    0,    0}};	//Loop
	int							VisRng;		//Visual Range Minimum
	int							ActRng;		//Active Range Minimum
	int							IntRng;		//Interactive Range Minimum

	virtual backdrop( ISceneNode, stringw, stringw, float, int, float, stringw );
	Update()
	{
		switch( this->Ste )
		{
			case "Active":
				//Animate ( 30 F/s )
				//Sound
				//Math
				break;
			default "Static":
				//Animate ( 30 F/s )
				//Sound
				//Math
				break;
		}
	};

	Collide( void Body )
	{
		string	BTyp	= typeid( Body ).name();

		//* Apply User Data
		if(	BTyp == "user" )
		{
			//Bend Backdrop
			if( this->Swy )
			{
				//Backdrop Sway
			}
			//* Damage
			if(	Hzd || Clp )
			{
				if(	Clp )
				{
					//Bump
					this->Hurt( Hzd, vector2df<s32>( 0, -0.16 * Hzd ).rotateBy( this->Nde.GetRotation().getY(), null ));
					list	Col	= Col.push_back( this->Ani[0][5] );
					Col.push_back( this->Nde.Current_Frame );
					this->Act.Pan( Col, user( Body ).Nde.getPosition().getDistanceFrom( this->Nde.getPosition()));
				}
				else
				{
					//Trip
					this->Hurt( Hzd, vector2df<s32>( 0, 0.16 * Hzd ).rotateBy( this->Nde.GetRotation().getY(), null ));
					list	Col	= Col.push_back( this->Ani[0][5] );
					Col.push_back( this->Nde.Current_Frame );
					this->Act.Pan( Col, user( Body ).Nde.getPosition().getDistanceFrom( this->Nde.getPosition()));
				}
			}
		}

		//* Apply entity Data
		else if( typeid( Body ).BTyp == "entity" )
		{

		}
		//* Apply Body Data
		else if( BTyp == "projectile" )
		{
			//* Damage
			if(	Clp ) projectile( Body ).Destroy();
			{
				//* Hurt
				//* Subtract Health From Backdrop
			}
		}
		//* Apply Backdrop Data
			//* Damage
	};

	Destroy()
	{
	};

	virtual ~backdrop();

private:
	list				Cnt;	//List of Backdrops
	ITriangleselector	Slc;	//Triangle selector
};
backdrop::backdrop( ISceneNode BNde, stringw BNam, stringw BAni, float BHzd, int BClp, float BHth, stringw BSte )
{
	this->Nde	= BNde;
	this->Nam	= BNam;
	this->Ani	= BAni;
	this->Hzd	= BHzd;
	this->Clp	= BClp;
	this->Hth	= BHth;
	this->Ste	= BSte;

	backdrop::Cnt::push_back( this );
	
	return this;
};
backdrop::~backdrop()
{
	this->Nde.remove();
	backdrop::Cnt.erase( this );

	return this;
};

class water : public backdrop
{
public:
	ITexture	Tex;		//Water Texture
	ITexture	Sps;		//Spash Texture
	vector2df	Cur;		//Velocity of Water Current

	water( ISceneNode WNde, stringw WNam, stringw WAni, float WHzd, int WClp, float WHth, stringw WSte, string WTex, vector2df WCur )
	{
		//*incomplete
		RealisticWaterSceneNode* realwater	= new RealisticWaterSceneNode( dev, 1228, 1640, driver->getTexture( "./waterbump.png" ), dev->getTimer());

		realwater->setPosition( vector3df( 154, -360, 603 ));
		realwater->setWaterColor( SColor( 0.1f, 0.1f, 0.6f, 1.0f ));
		realwater->setWindForce( 10.0f );
		realwater->setSplitScreen( true );
		//*incomplete

		this->Nde	= WNde;
		this->Nam	= WNam;
		this->Ani	= WAni;
		this->Hzd	= WHzd;
		this->Clp	= WClp;
		this->Hth	= WHth;
		this->Ste	= WSte;
		this->Tex	= WTex;
		this->Cur	= WCur;

		water::Cnt::push_back( this );
		//ListAddLast( Cnt, this );
		//ListAddLast( WtrCnt, this );
		return this;
	};
	Update()
	{
		backdrop::Update();
		switch( Ste )
		{
			case "Active";
				//Logic
				//Sound
				break;
			default "Still":
				//Logic
				//Sound
				break;
		}
	}
	Collide( void Body )
	{
		Body.Collide( void Body );
	}
	Flow()
	{
	}
	Calm()
	{
	}
	~water()
	{
		this->Nde.remove();
		water::Cnt.erase( this );
	};
private:
	list	Cnt;		//List of Waters
};

class wind : public backdrop
{
public:
	vector3df	Vlc;		//Velocity of Wind

	wind( ISceneNode WNde, string WNam, string WAni, float WHzd, int WClp, float WHth, string WSte, vector3df WVel )
	{
		this->Nde	= WNde;
		this->Nam	= WNam;
		this->Ani	= WAni;
		this->Hzd	= WHzd;
		this->Clp	= WClp;
		this->Hth	= WHth;
		this->Ste	= WSte;
		this->Vlc	= WVel;

		//* incomplete linked list
		backdrop::Cnt.push_back( this );
		wind::Cnt.push_back( this );

		return this;
	}
	Update()
	{
		Backdrop.Update();
		switch( Ste )
		{
			case "Blowing";
				//Logic
				//Sound

			case "Calm";
				//Logic
				//Sound
		default;
		}
	}
	Collide( void Body )
	{
		Backdrop.Collide( void Body );
	}
	Blow()
	{
	}
	Calm()
	{
	}
	~wind()
	{
		wind::Cnt.erase( this );

		return this;
	};

private:
	list	Cnt;		//List of Winds
};

class ladder : public backdrop
{
public:
	vector3df	Dir;	//Direction of Ladder
	float		Rad;	//Ladder Climbing Face Radius

	ladder( ISceneNode LNde, string LNam, string LAni, float LHzd, int LClp, float LHth, string LSte, vector3df LDir, float LRad )
	{
		this->Nde	= LNde;
		this->Nam	= LNam;
		this->Ani	= LAni;
		this->Hzd	= LHzd;
		this->Clp	= LClp;
		this->Hth	= LHth;
		this->Ste	= LSte;
		this->Dir	= LDir;
		this->Rad	= LRad;

		backdrop::Cnt.push_back( this );
		ladder::Cnt.push_back( this );

		return this;
	};
	Update()
	{
		backdrop.Update();
	}
	~ladder()
	{
		ladder::Cnt.erase( this );
	};
private:
	list	Cnt;	//List of Ladders


};
